/*
 * %W% %E%
 *
 * Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */
package javax.swing.text;

import java.awt.*;

/**
 * A class to perform rendering of the glyphs.
 * This can be implemented to be stateless, or
 * to hold some information as a cache to 
 * facilitate faster rendering and model/view
 * translation.  At a minimum, the GlyphPainter
 * allows a View implementation to perform its
 * duties independent of a particular version
 * of JVM and selection of capabilities (i.e.
 * shaping for i18n, etc).
 * <p>
 * This implementation is intended for operation
 * under the JDK1.1 API of the Java Platform.
 * Since the JDK is backward compatible with
 * JDK1.1 API, this class will also function on
 * Java 2.  The JDK introduces improved 
 * API for rendering text however, so the GlyphPainter2
 * is recommended for the DK.
 *
 * @author  Timothy Prinzing
 * @version %I% %G%
 * @see GlyphView
 */
class GlyphPainter1 extends GlyphView.GlyphPainter {

    /**
     * Determine the span the glyphs given a start location
     * (for tab expansion).
     */
    public float getSpan(GlyphView v, int p0, int p1, 
			 TabExpander e, float x) {
	sync(v);
	Segment text = v.getText(p0, p1);
        int[] justificationData = getJustificationData(v);
        int width = Utilities.getTabbedTextWidth(v, text, metrics, (int) x, e, p0, 
                                                 justificationData);
        SegmentCache.releaseSharedSegment(text);
	return width;
    }

    public float getHeight(GlyphView v) {
	sync(v);
	return metrics.getHeight();
    }

    /**
     * Fetches the ascent above the baseline for the glyphs
     * corresponding to the given range in the model.
     */
    public float getAscent(GlyphView v) {
	sync(v);
	return metrics.getAscent();
    }

    /**
     * Fetches the descent below the baseline for the glyphs
     * corresponding to the given range in the model.
     */
    public float getDescent(GlyphView v) {
	sync(v);
	return metrics.getDescent();
    }

    /**
     * Paints the glyphs representing the given range.
     */
    public void paint(GlyphView v, Graphics g, Shape a, int p0, int p1) {
	sync(v);
	Segment text;
	TabExpander expander = v.getTabExpander();
	Rectangle alloc = (a instanceof Rectangle) ? (Rectangle)a : a.getBounds();

	// determine the x coordinate to render the glyphs
	int x = alloc.x;
	int p = v.getStartOffset();
        int[] justificationData = getJustificationData(v);
	if (p != p0) {
	    text = v.getText(p, p0);
            int width = Utilities.getTabbedTextWidth(v, text, metrics, x, expander, p, 
                                                     justificationData);
	    x += width;
            SegmentCache.releaseSharedSegment(text);
	}

	// determine the y coordinate to render the glyphs
	int y = alloc.y + metrics.getHeight() - metrics.getDescent();

	// render the glyphs
	text = v.getText(p0, p1);
	g.setFont(metrics.getFont());

        Utilities.drawTabbedText(v, text, x, y, g, expander,p0, 
                                 justificationData);
        SegmentCache.releaseSharedSegment(text);
    }

    public Shape modelToView(GlyphView v, int pos, Position.Bias bias,
			     Shape a) throws BadLocationException {

        sync(v);
	Rectangle alloc = (a instanceof Rectangle) ? (Rectangle)a : a.getBounds();
	int p0 = v.getStartOffset();
	int p1 = v.getEndOffset();
	TabExpander expander = v.getTabExpander();
	Segment text;

	if(pos == p1) {
	    // The caller of this is left to right and borders a right to
	    // left view, return our end location.
	    return new Rectangle(alloc.x + alloc.width, alloc.y, 0,
				 metrics.getHeight());
	}
	if ((pos >= p0) && (pos <= p1)) {
	    // determine range to the left of the position
	    text = v.getText(p0, pos);
            int[] justificationData = getJustificationData(v);
            int width = Utilities.getTabbedTextWidth(v, text, metrics, alloc.x, expander, p0, 
                                                     justificationData);
            SegmentCache.releaseSharedSegment(text);
	    return new Rectangle(alloc.x + width, alloc.y, 0, metrics.getHeight());
	}
	throw new BadLocationException("modelToView - can't convert", p1);
    }

    /**
     * Provides a mapping from the view coordinate space to the logical
     * coordinate space of the model.
     *
     * @param v the view containing the view coordinates
     * @param x the X coordinate
     * @param y the Y coordinate
     * @param a the allocated region to render into
     * @param biasReturn always returns <code>Position.Bias.Forward</code>
     *   as the zero-th element of this array
     * @return the location within the model that best represents the
     *  given point in the view
     * @see View#viewToModel
     */
    public int viewToModel(GlyphView v, float x, float y, Shape a, 
			   Position.Bias[] biasReturn) {

        sync(v);
	Rectangle alloc = (a instanceof Rectangle) ? (Rectangle)a : a.getBounds();
	int p0 = v.getStartOffset();
	int p1 = v.getEndOffset();
	TabExpander expander = v.getTabExpander();
	Segment text = v.getText(p0, p1);
        int[] justificationData = getJustificationData(v);
        int offs = Utilities.getTabbedTextOffset(v, text, metrics, 
                                                 alloc.x, (int) x, expander, p0, 
                                                 justificationData);
        SegmentCache.releaseSharedSegment(text);
	int retValue = p0 + offs;
	if(retValue == p1) {
            // No need to return backward bias as GlyphPainter1 is used for
            // ltr text only.
            retValue--;
        }
        biasReturn[0] = Position.Bias.Forward;
	return retValue;
    }

    /**
     * Determines the best location (in the model) to break
     * the given view.
     * This method attempts to break on a whitespace
     * location.  If a whitespace location can't be found, the
     * nearest character location is returned.
     *
     * @param v the view 
     * @param p0 the location in the model where the
     *  fragment should start its representation >= 0
     * @param pos the graphic location along the axis that the
     *  broken view would occupy >= 0; this may be useful for
     *  things like tab calculations
     * @param len specifies the distance into the view
     *  where a potential break is desired >= 0  
     * @return the model location desired for a break
     * @see View#breakView
     */
    public int getBoundedPosition(GlyphView v, int p0, float x, float len) {
	sync(v);
	TabExpander expander = v.getTabExpander();
	Segment s = v.getText(p0, v.getEndOffset());
        int[] justificationData = getJustificationData(v);
        int index = Utilities.getTabbedTextOffset(v, s, metrics, (int)x, (int)(x+len),
                                                  expander, p0, false, 
                                                  justificationData);
        SegmentCache.releaseSharedSegment(s);
	int p1 = p0 + index;
	return p1;
    }

    void sync(GlyphView v) {
	Font f = v.getFont();
	if ((metrics == null) || (! f.equals(metrics.getFont()))) {
	    // fetch a new FontMetrics
            Container c = v.getContainer();
            metrics = (c != null) ? c.getFontMetrics(f) :
                Toolkit.getDefaultToolkit().getFontMetrics(f);
	}
    }



    /**
     * @return justificationData from the ParagraphRow this GlyphView
     * is in or {@code null} if no justification is needed
     */
    private int[] getJustificationData(GlyphView v) {
        View parent = v.getParent();
        int [] ret = null;
        if (parent instanceof ParagraphView.Row) {
            ParagraphView.Row row = ((ParagraphView.Row) parent);
            ret = row.justificationData;
        } 
        return ret;
    }
    
    // --- variables ---------------------------------------------

    FontMetrics metrics;
}
